//package com.spzx.test1.Day3Test;
//
//import java.util.concurrent.CompletableFuture;
//import java.util.concurrent.LinkedBlockingQueue;
//import java.util.concurrent.ThreadPoolExecutor;
//import java.util.concurrent.TimeUnit;
//import java.util.function.BiConsumer;
//import java.util.function.Function;
//import java.util.function.Supplier;
//
//public class Test2 {
//
//    public static void main(String[] args) throws InterruptedException {
//
//        long start = System.currentTimeMillis();
//
//        ThreadPoolExecutor pool = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1024));
//
//        System.out.println(Thread.currentThread().getName()+"主线程开始执行。。。。");
//
//        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"执行无返回值任务。。。。");
//            }
//        },pool);
//
//        CompletableFuture<Integer> returnCompletableFuture =CompletableFuture.supplyAsync(new Supplier<Integer>() {
//            @Override
//            public Integer get() {
//                System.out.println(Thread.currentThread().getName()+"执行有返回值任务。。。。");
//                return 100;
//            }
//        },pool);
//
//        CompletableFuture<Integer> thenCompletableFuture1 = returnCompletableFuture.thenApplyAsync(new Function<Integer, Integer>() {
//            @Override
//            public Integer apply(Integer integer) {
//                System.out.println(Thread.currentThread().getName() + "我是completableFuture的接力线程，我得到了一个值：" + integer);
//                Integer a = integer * 2;
//                return a;
//            }
//        },pool);
//
//
//        CompletableFuture<Integer> whenCompletableFuture = thenCompletableFuture1.whenCompleteAsync(new BiConsumer<Integer, Throwable>() {
//            @Override
//            public void accept(Integer integer, Throwable throwable) {
//                try {
//                    Thread.sleep(3000);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//                System.out.println(Thread.currentThread().getName()+"收尾线程，获得返回结果："+integer);
//
//            }
//        },pool);
//
//
//        Thread.sleep(2000);
//
//        CompletableFuture.allOf(voidCompletableFuture,returnCompletableFuture,thenCompletableFuture1,whenCompletableFuture).join();
//
//        System.out.println(Thread.currentThread().getName()+"主线程执行结束。。。。");
//
//        long end = System.currentTimeMillis();
//
//        System.out.println("耗时："+(end-start)+"毫秒");
//
//        pool.shutdown();
//
//    }
//}



package com.spzx.test1.Day3Test;

// 导入必要的类
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class Test2 {

    public static void main(String[] args) throws InterruptedException {

        // 记录开始时间，用于计算程序执行的总时间
        long start = System.currentTimeMillis();

        // 创建一个线程池，核心线程数和最大线程数都是10，线程空闲时存活时间为0秒，使用LinkedBlockingQueue作为任务队列
        ThreadPoolExecutor pool = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1024));

        // 打印主线程开始执行的日志
        System.out.println(Thread.currentThread().getName()+"主线程开始执行。。。。");

        // 异步执行一个无返回值的任务
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(new Runnable() {
            @Override
            public void run() {
                // 打印当前线程名称和执行的任务信息
                System.out.println(Thread.currentThread().getName()+"执行无返回值任务。。。。");
            }
        }, pool);

        // 异步执行一个有返回值的任务
        CompletableFuture<Integer> returnCompletableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                // 打印当前线程名称和执行的任务信息
                System.out.println(Thread.currentThread().getName()+"执行有返回值任务。。。。");
                // 返回一个整数值
                return 100;
            }
        }, pool);

        // 在有返回值的任务完成后，异步应用一个函数
        CompletableFuture<Integer> thenCompletableFuture1 = returnCompletableFuture.thenApplyAsync(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) {
                // 打印当前线程名称和接收到的值
                System.out.println(Thread.currentThread().getName() + "我是completableFuture的接力线程，我得到了一个值：" + integer);
                // 将接收到的值乘以2并返回
                Integer a = integer * 2;
                return a;
            }
        }, pool);

        // 在接力任务完成后，异步执行一个收尾操作
        CompletableFuture<Integer> whenCompletableFuture = thenCompletableFuture1.whenCompleteAsync(new BiConsumer<Integer, Throwable>() {
            @Override
            public void accept(Integer integer, Throwable throwable) {
                try {
                    // 模拟一些处理时间
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                // 打印当前线程名称和接收到的结果
                System.out.println(Thread.currentThread().getName()+"收尾线程，获得返回结果："+integer);
            }
        }, pool);

        // 主线程等待一段时间，确保所有异步任务有足够的时间执行
        Thread.sleep(2000);

        // 等待所有异步任务完成
        CompletableFuture.allOf(voidCompletableFuture, returnCompletableFuture, thenCompletableFuture1, whenCompletableFuture).join();

        // 打印主线程结束执行的日志
        System.out.println(Thread.currentThread().getName()+"主线程执行结束。。。。");

        // 记录结束时间，并计算程序执行的总时间
        long end = System.currentTimeMillis();
        System.out.println("耗时："+(end-start)+"毫秒");

        // 关闭线程池
        pool.shutdown();
    }
}